home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / System / Idle DA's / Poly.c < prev   
Encoding:
C/C++ Source or Header  |  1986-11-05  |  3.2 KB  |  186 lines  |  [TEXT/MACA]
  1. /*
  2.  * general polygon idle desk accessory
  3.  *
  4.  * bounce points with random speeds
  5.  * save in queue
  6.  * connect the dots...
  7.  *
  8.  * keyboard commands:
  9.  *
  10.  *    0-9    select # points in polygon (0 or 1 means 10)
  11.  *    [    shorten queue
  12.  *    ]    lengthen queue
  13.  *    q    quantize point speed
  14.  */
  15. #include <hd20:lightspeed:mac:quickdraw.h>
  16.  
  17. #define    nQueue        100    /* max polygons in queue */
  18. #define    qInit        20    /* initial queue size */
  19. #define    qIncr        10    /* queue size increment */
  20. #define    nPoints        10    /* max points per poly */
  21. #define    pInit        4    /* initial # points */
  22.  
  23. int    quantize;    /* quantize point deltas */
  24. /*
  25.  * bouncing points - 1st is value, 2nd is delta, each w/16 bit fraction
  26.  */
  27. long    x[nPoints][2],
  28.     y[nPoints][2];
  29. /*
  30.  * polygon queue
  31.  */
  32. int    qHead, qTail, qSize, nPinQ, pSize;
  33. Point    pQueue[nQueue][nPoints];
  34. /*
  35.  * compute new delta
  36.  */
  37. long
  38. newDelta(range)
  39. int range;
  40. {
  41.     register int r;
  42.     register long d;
  43.  
  44.     if ((r = Random()) < 0)
  45.         r = -r;
  46.     d = ((long)range << 16) / (r % range + 1);
  47.     if (quantize && (d = (d + 0x7FFFL) & ~0xFFFFL) == 0)
  48.         d = 0x10000L;
  49.     return d;
  50. }
  51. /*
  52.  * compute new point
  53.  */
  54. newPoint(p, lo, hi)
  55. long *p;
  56. int lo, hi;
  57. {
  58.     register int v;
  59.  
  60.     v = p[0] >> 16;
  61.     if (v < lo) {
  62.         v = lo;
  63.         p[1] = newDelta(hi - lo);
  64.     }
  65.     else if (v > hi) {
  66.         v = hi;
  67.         p[1] = -newDelta(hi - lo);
  68.     }
  69.     p[0] += p[1];
  70.     return v;
  71. }
  72. /*
  73.  * connect the dots...
  74.  */
  75. drawShape(n, p)
  76. register int n;
  77. Point *p;
  78. {
  79.     MoveTo(p[0].h, p[0].v);
  80.     if (n == 2)
  81.         LineTo(p[1].h, p[1].v);
  82.     else while (--n >= 0)
  83.         LineTo(p[n].h, p[n].v);
  84. }
  85. /*
  86.  * initialize stuff
  87.  */
  88. initIdle(rp)
  89. Rect *rp;
  90. {
  91.     register int i;
  92.  
  93.     nPinQ = 0;
  94.     qHead = 0;
  95.     qTail = 0;
  96.     qSize = qInit;
  97.     pSize = pInit;
  98.  
  99.     for (i = 0; i < nPoints; ++i) {
  100.         if (i & 1) {    /* L->R */
  101.             x[i][1] = newDelta(rp->right - rp->left);
  102.             x[i][0] = ((long)rp->left << 16) + x[i][1];
  103.         }
  104.         else {        /* R->L */
  105.             x[i][1] = -newDelta(rp->right - rp->left);
  106.             x[i][0] = ((long)rp->right << 16) + x[i][1];
  107.         }
  108.         if (i & 2) {    /* T->B */
  109.             y[i][1] = -newDelta(rp->bottom - rp->top);
  110.             y[i][0] = ((long)rp->bottom << 16) + y[i][1];
  111.         }
  112.         else {        /* B->T */
  113.             y[i][1] = newDelta(rp->bottom - rp->top);
  114.             y[i][0] = ((long)rp->top << 16) + y[i][1];
  115.         }
  116.     }
  117. }
  118. /*
  119.  * drawing routine
  120.  */
  121. runIdle(rp)
  122. Rect *rp;
  123. {
  124.     register int i;
  125.  
  126.     ObscureCursor();
  127.     /*
  128.      * undraw stuff at head of queue - shorten if necessary
  129.      */
  130.     while (nPinQ >= qSize) {
  131.         drawShape(pSize, pQueue[qHead]);
  132.         if (++qHead >= nQueue)
  133.             qHead = 0;
  134.         --nPinQ;
  135.     }
  136.     /*
  137.      * compute next set of points
  138.      */
  139.     for (i = 0; i < nPoints; ++i) {
  140.         pQueue[qTail][i].h = newPoint(x[i], rp->left, rp->right);
  141.         pQueue[qTail][i].v = newPoint(y[i], rp->top, rp->bottom);
  142.     }
  143.     /*
  144.      * draw newest polygon
  145.      */
  146.     drawShape(pSize, pQueue[qTail]);
  147.     if (++qTail >= nQueue)
  148.         qTail = 0;
  149.     ++nPinQ;
  150. }
  151. /*
  152.  * key events come here
  153.  */
  154. keyIdle(c)
  155. {
  156.     switch (c) {
  157.     case '[':    /* shorten */
  158.         if ((qSize -= qIncr) < qIncr)
  159.             qSize = qIncr;
  160.         break;
  161.     case ']':    /* lengthen */
  162.         if ((qSize += qIncr) > nQueue)
  163.             qSize = nQueue;
  164.         break;
  165.     case 'q':
  166.         quantize = !quantize;
  167.         break;
  168.     case '1': case '0':
  169.         c = 10;
  170.         goto newSize;
  171.     case '2': case '3': case '4': case '5':
  172.     case '6': case '7': case '8': case '9':
  173.         c -= '0';
  174.     newSize:
  175.         ObscureCursor();
  176.         while (nPinQ > 0) {
  177.             drawShape(pSize, pQueue[qHead]);
  178.             if (++qHead >= nQueue)
  179.                 qHead = 0;
  180.             --nPinQ;
  181.         }
  182.         pSize = c;
  183.         break;
  184.     }
  185. }
  186.